import AsyncStorage from '../utils/AsyncStorage';
import FsStore from '../utils/FsStore';
import productJson from './product_ext.json';
import { getTemplateConfig } from './template';
import { correctProduct, correctProducts, getProductLanguageJson } from './utils';

type supportSceneType = 'result' | 'condition';
type sceneType = 'Boolean' | 'Number' | 'Enumeration';
interface IEnumerationValue {
  name: string;
  attrs: string;
  value: string;
}
interface IFeature {
  id: string;
  controllable: boolean;
  displayName: string;
  name: string;
  handleType: 'status_writable' | 'status_readonly';
  requisite: boolean;
  type: sceneType;
  isActive: boolean;
  isFeatureCount?: boolean; // 是否要统计
  sceneType: supportSceneType[];
  min?: number;
  max?: number;
  step?: number;
  value?: IEnumerationValue[] | boolean;
  icon?: string;
}

interface ITemplateConfig {
  stylesConfig?: any[];
  expandFeatureList?: IFeature[];
  featureList: IFeature[];
}

const TNetworkConfigTypeSoftAp = 'SOFT_AP'; // SoftAp配网
const TNetworkConfigTypeAirLink = 'AIR_LINK'; // AirLink配网
const TNetworkConfigTypeAuto = 'AUTO'; // AirLink与SoftAp配网
const TNetworkConfigTypeBTWifi = 'BT_WIFI'; // 蓝牙配网
const TNetworkConfigTypeLan = 'LAN'; // 小循环添加
const TNetworkConfigTypeBle = 'BLE'; // 蓝牙添加
const TNetworkConfigTypeNFC = 'NFC'; // NFC配网

export const networkConfigTypes = {
  TNetworkConfigTypeSoftAp,
  TNetworkConfigTypeAirLink,
  TNetworkConfigTypeAuto,
  TNetworkConfigTypeBTWifi,
  TNetworkConfigTypeBle,
  TNetworkConfigTypeLan,
  TNetworkConfigTypeNFC,
};

export type TNetworkConfigTypeEnu =
  | TNetworkConfigTypeAuto
  | TNetworkConfigTypeSoftAp
  | TNetworkConfigTypeAirLink
  | TNetworkConfigTypeBTWifi
  | TNetworkConfigTypeLan
  | TNetworkConfigTypeBle
  | TNetworkConfigTypeNFC;

/**
* 指令限制规则
最小触发持续时间 t = 5000ms
最小触发间隔 dlt = 0ms
最小触发次数 n = 5次
限制下发时间 l = 2000ms
限制时间长度 d = 6000ms

在t时间内，下次的前n条数据按dlt限制下发频率，如果用户在dlt内下发，则app不处理；
大于n的，则会触发限制开启，开启后，下发频率会限制l秒下发一次，在限制下发时间内，用户操作app则弹提示，d秒后会解除这个限制
提示语：操作太快了，请慢一点
如果最小触发时间为0，代表不限制；由于是设备在接收指令太多的时候会Crash，所以这里不针对下发渠道（wifi，蓝牙，小循环等），只要下发指令就会触发这个规则
*/
export interface ICmdLimitConfig {
  limitMinTime: number; // 最小触发持续时间，单位毫秒
  limitUnitTime: number; // 最小触发间隔，单位毫秒
  limitMinCount: number; // 最小触发次数
  lockTime: number; // 限制下发时间，单位毫秒
  unlockTime: number; // 限制时间长度，单位毫秒
}

export enum DataType {
  Enum = 'Enumeration', // 枚举型
  Bool = 'Boolean', // 布尔型
  Number = 'Number', // 数值型
}
export interface ISchedulerOption {
  value: any;
  label: string;
}

export enum ComponentType {
  Input = 'input', // 输入
}
export interface ISchedulerConfig {
  name: string; // 定时操作显示的名称
  attr: string; // 定时要发送指令的数据点key
  dataType: DataType; // 类型，支持布尔，枚举，数值型
  componentType?: ComponentType; // 控件类型，主要是给数值型使用，目前只有input支持，太大的数字用滑动条难精准滑到，就用输入框
  min?: number; // 类型为number必填，数值的最小值
  max?: number; // 类型为number必填，数值的最大值
  step?: number; // 类型为number才有效，数值的步进值，不配置默认为1
  options?: ISchedulerOption[]; // 选项数组；布尔，枚举生效，对应的值与显示的名字；布尔值可不配置，则默认显示打开关闭
  defaultValue?: any; // 默认值，可不配置，布尔默认false，数值默认最小值，枚举默认options第一个
  unit?: string; // 单位，数值型生效，会显示在数值后面
}

interface IProduct {
  icon: string;
  productSecret: string;
  productKey: string;
  name: string;
  isDev?: boolean;
  templateId: string;
  templateConfig: ITemplateConfig;
  dpQueryKeys?: string[]; // 作用于getDeviceStatus，如果 getDeviceStatus 没有传Attr，会来这里找
  usingAdapter?: string;
  useOtherProductTemplate?: string; // 使用其他模版
  moduleType?: number[];
  templateDownloadUrl?: string;
  productTypeBTRegular?: string; // 蓝牙匹配正则
  gid?: string;
  supportGroup?: boolean;
  groupIcon?: string;
  m2mProtoc?: M2mProtoc;
  language: any;
  airLink?: IConfigDeviceTips;
  softAp?: IConfigDeviceTips;
  btWifi?: IConfigDeviceTips;
  resetDevice?: IConfigDeviceTips;
  ble?: IConfigDeviceTips;
  softAPPassword?: string;
  mainGroup?: boolean;
  brand?: IBrand;
  networkConfigType: TNetworkConfigTypeEnu[];
  powerAttr?: string;
  isGatewayProduct?: boolean; // 是否是网关
  isGatewaySubdeviceProduct?: boolean; // 是否是子设备
  softAPSSIDPrefix?: string;
  notSoftAPSSIDSuffix?: boolean; // 是否不带后缀匹配
  supportProduct?: string[]; // 网关用，支持的产品
  disableExperience?: boolean; // 是否不显示在体验中心
  isCenterControlProduct?: boolean; // 是否是中空
  scene?: IScene;
  alarmConfig?: {
    alarms?: IAlarm[];
    faultIcon?: string; // 故障图表
    alertIcon?: string; // 告警图表
  };
  isLowPower?: boolean; // 是否是低功耗设备
  convenientControl?: IConvenientControl[];
  convenientState?: IConvenientState[];
  offlineIcon?: string;
  expId?: string;
  isFromRemote?: boolean;
  disableProductList?: boolean; // 是否显示在产品列表
  wxTemplateId: string; // 微信的模板id
  deviceTimeCorrect?: boolean; // 是否支持时间校准功能
  passwordVerify?: boolean; // 是否需要校验密码
  sendCmdLinit?: ICmdLimitConfig;
  supportDeviceShare?: boolean; // 是否支持设备分享
  supportDeviceAlarm?: boolean; // 是否支持设备告警设置
  supportBleAdd?: boolean; // 是否支持蓝牙添加，前提是需要通讯协议是BLE或者双模的设备
  supportBleControl?: boolean; // 只对双模设备有效，是否开放蓝牙控制
  m2mProtocSort?: M2mProtoc[]; // 通讯协议优先级，不配置默认是蓝牙优先级高于wifi
  wxModelId?: string; // 微信的设备id
  isBleBroadcast: boolean; // 是否为蓝牙广播
  schedulerConfig: ISchedulerConfig[]; // 定时配置
}

export interface IAlarm {
  name: string;
  icon?: string;
  type: 'alerts' | 'faults';
  level: number;
  conditions: IAlarmCondition[];
  logic: string;
  action?: IAlarmAction;
}

interface IAlarmCondition {
  name: string;
  left: any;
  right: any;
  opt: any;
}

interface IAlarmAction {
  type: string;
  content: {
    title?: string;
    rowText?: string;
  }[];
}

interface IScene {
  icon?: any;
  name?: any;
  taskTypes: ISceneItem[];
  id: number;
}
interface ISceneItem {
  name: string;
  dataType?: sceneType;
  min?: number;
  max?: number;
  step?: number;
  attr?: string;
  defaultAttrs?: any;
  support?: supportSceneType[];
  options?: { value: any; label: string }[];
  value?: any;
  type?: undefined | 'alert' | 'fault' | 'normarl';
}

interface IConfigDeviceTips {
  content: IMediaItem[];
  language: any;
  noResetTips?: boolean;
}

interface IBrand {
  products: IProduct[];
  id: string;
  name: string;
}

interface IConvenientControlValueOption {
  value: any; // 数据点可选值数组
  image: string; // 当数据点达到value时要显示的图片url
  name: string; // 状态名称的key，比如打开，关闭
  notInOption?: boolean; // 是否不在高亮计算范围
}

interface IConvenientControl {
  id: string; // id
  attrs: string; // 数据点名称
  attrsIcon: string; // 快捷控制图标
  type: 'Boolean' | 'Number' | 'Enumeration'; // 数据点数据类型
  editName: string; // 编辑显示的名称Key，具体名字在配置的language中获取
  option: IConvenientControlValueOption[]; // 可选值数组
}

interface IConvenientStateTitle {
  text: string; // 标题要显示的文案
}

export interface IConvenientStateCondition {
  opt: '<' | '>' | '<=' | '>=' | '==' | '!='; // 比较符号
  value: any; // 比较数值
}

interface IConvenientStateFormatTitle {
  type: 'Date'; // 支持格式化标题，会覆盖IConvenientStateTitle配置
}

interface IConvenientStateContent {
  conditions: IConvenientStateCondition[]; // 显示需要满足的条件
  text?: string; // 满足条件要显示的文案
  image?: string; // 满足条件要显示的图片
  formatTitle?: IConvenientStateFormatTitle; // 格式化标题配置
}

interface IConvenientState {
  id: string; // id
  attrs: string; // 数据点名称
  type: 'Boolean' | 'Number' | 'Enumeration'; // 数据点数据类型
  editName: string; // 编辑显示的名称Key，具体名字在配置的language中获取
  title?: IConvenientStateTitle; // 显示标题
  content: IConvenientStateContent[];
}

type M2mProtoc =
  | 'BT'
  | 'BLE'
  | 'MESH'
  | 'WIFI'
  | 'CELLULAR'
  | 'NBIOT'
  | 'THIRD_CLOUD'
  | 'COM'
  | 'RF'
  | 'LORA'
  | 'MESH'
  | 'ZIGBEE'
  | 'BLE_BROADCAST'; // 废弃

interface IProductConfig {
  data: IProduct[]; // 修正后的产品配置
  appProducts: any[]; // APP本地产品配置
  cacheProducts: IProduct[] | null; // 从接口获取，在缓存中的产品配置
  init: () => {}; // 初始化产品配置
  getCacheProducts: () => Promise<IProduct[]>; // 获取缓存产品配置
  updateCacheProducts: (products: IProduct[]) => {}; // 更新缓存产品配置
  updateCacheProduct: (product: IProduct) => {}; // 更新缓存中某个产品配置
  addProduct: (product: IProduct) => {}; // 添加产品到产品配置
  getItemForPk: (pk: string) => IProduct | undefined; // 根据PK获取某个产品配置
  getConfig: () => IProduct[]; // 获取修正后的产品配置
  getProductNameFromConfig: (languageKey: string, product?: IProduct, isExprience?: boolean) => string; // 获取某个产品的名称
  getProductName: (pk: string, languageKey: string, isExprience?: boolean) => string; // 获取某个产品的名称
  getProductLanguageByConfig: (
    // 获取某个产品某个语言的多语言配置
    product: IProduct | undefined,
    languageKey: string,
    key: string
  ) => {};
  getProductLanguageByPK: (
    // 根据PK获取某个产品某个语言的多语言配置
    pk: string,
    languageKey: string,
    key: string
  ) => {};
  productKeys: string[]; // 已有的pk列表
  hasProductSupportDeviceShare(): boolean;
}

const ProductStorage = new FsStore('products');
const cacheProductsKey = 'cacheProducts_new';
export const cacheUpdateAtKey = 'productCongfiUpdateAt_new';

const ProductConfig: IProductConfig = {
  data: correctProducts(productJson.product_list, getTemplateConfig().supportLanguages) as IProduct[], // 默认值是APP本地产品配置
  appProducts: productJson.product_list,
  cacheProducts: null,
  productKeys: [],

  async init() {
    // 初始化产品配置
    const templateConfig = getTemplateConfig();

    const products = [...this.appProducts];
    const cacheProducts = await this.getCacheProducts();

    cacheProducts.forEach((item: IProduct) => {
      const targetIndex = this.appProducts.findIndex(
        (productItem: IProduct) => productItem.productKey === item.productKey
      );
      if (targetIndex === -1) {
        products.push(item);
      } else {
        // 替换
        products.splice(targetIndex, 1, item);
      }
    });

    // const list = products.filter(i=>i.templateId === 'com.gizwits.rn.shake.1');
    // const pk = list.map(i=>{return {productKey:i.productKey,name:i.name}});
    // console.log('productslist',pk);

    this.data = correctProducts(products, templateConfig.supportLanguages) as IProduct[];

    // 超赛上会有pk为空的配置，这里防御一下
    this.data = this.data.filter(i => !!i.productKey);

    this.productKeys = this.data.map(item => item.productKey);
  },
  async getCacheProducts() {
    // 获取缓存产品配置
    if (!this.cacheProducts) {
      const cacheProductsStr = await ProductStorage.getItem(cacheProductsKey);
      this.cacheProducts = JSON.parse(cacheProductsStr || '[]');
    }
    return this.cacheProducts as IProduct[];
  },
  async updateCacheProducts(products) {
    if (products.length === 0) {
      // 等于0不用处理
      return;
    }
    const cacheProducts = await this.getCacheProducts();

    products.forEach((newProduct: IProduct) => {
      // 判断缓存产品列表
      const sameIndex = cacheProducts.findIndex((oldProduct: IProduct) => {
        return oldProduct.productKey === newProduct.productKey;
      });
      if (sameIndex > -1) {
        cacheProducts[sameIndex] = { ...cacheProducts[sameIndex], ...newProduct };
      } else {
        cacheProducts.push({ ...newProduct, isFromRemote: true });
      }
    });

    this.cacheProducts = cacheProducts;
    // console.log('this.cacheProducts', this.cacheProducts);
    // 重新初始化配置
    await this.init();
    await ProductStorage.setItem(cacheProductsKey, JSON.stringify(this.cacheProducts));
    await AsyncStorage.setItem(cacheUpdateAtKey, String(Date.now()));
  },
  async updateCacheProduct(data) {
    // 更新缓存产品配置
    const cacheProducts: IProduct[] = await this.getCacheProducts();

    // 检查是否重复，重复覆盖，不存在则插入
    const index = cacheProducts.findIndex(item => item.productKey === data.productKey);
    if (index !== -1) {
      cacheProducts[index] = data;
    } else {
      cacheProducts.push(data);
    }
    this.cacheProducts = cacheProducts;
    ProductStorage.setItem(cacheProductsKey, JSON.stringify(this.cacheProducts));
  },
  async addProduct(data) {
    // 增加配置
    const target = this.data.findIndex((item: IProduct) => item.productKey === data.productKey);
    const product: IProduct = correctProduct(data, getTemplateConfig().supportLanguages) as IProduct;
    if (target === -1) {
      this.data.push(product);
    } else {
      // 替换
      this.data.splice(target, 1, product);
    }
    this.updateCacheProduct(product);
  },
  getItemForPk(pk) {
    return this.data.find(p => p.productKey === pk);
  },
  getConfig() {
    console.log('getConfig');
    return this.data;
  },
  getProductNameFromConfig(languageKey: string, product?: IProduct, isExprience?: boolean) {
    if (!product) {
      return '';
    }
    const languageJson = getProductLanguageJson(product, languageKey);
    // 如果是体验中心获取产品名字，优先返回已配置的体验中心产品名
    const expName = isExprience ? languageJson.EXP_PRODUCT_NAME : null;
    return expName || languageJson.PL_PRODUCT_NAME;
  },
  getProductName(pk: string, languageKey: string, isExprience?: boolean) {
    const product = this.getItemForPk(pk);
    console.log('product', product, pk, languageKey);
    return this.getProductNameFromConfig(languageKey, product, isExprience);
  },
  getProductLanguageByConfig(product, languageKey, key: string) {
    if (!product) {
      return '';
    }
    const languageJson = getProductLanguageJson(product, languageKey);
    return languageJson[key];
  },
  getProductLanguageByPK(pk: string, languageKey: string, key: string) {
    const product = this.getItemForPk(pk);
    return this.getProductLanguageByConfig(product, languageKey, key);
  },
  hasProductSupportDeviceShare() {
    return (this.data as IProduct[]).some(p => getConfigSupportShare(p));
  }
};

export default ProductConfig;

export const getItemForPk = ProductConfig.getItemForPk.bind(ProductConfig);
export const getConfig = ProductConfig.getConfig.bind(ProductConfig);
export const getProductName = ProductConfig.getProductName.bind(ProductConfig);
export const getProductNameFromConfig = ProductConfig.getProductNameFromConfig.bind(ProductConfig);
export const getProductLanguage = ProductConfig.getProductLanguageByPK.bind(ProductConfig);
export const getProductLanguageByConfig = ProductConfig.getProductLanguageByConfig.bind(ProductConfig);

/**
 * 允许指定一个产品列表
 * @param {Arrary} specifiedList
 */
export function getGroupConfig(specifiedList?: IProduct[]) {
  const list = specifiedList || getConfig();
  return list.filter(item => {
    if (item.gid) {
      // 存在gid
      return !!item.mainGroup;
    }
    // 不存在
    return true;
  });
}

/**
 * 根据PK列表获取对应产品配置
 * @param {Arrary} specifiedList
 */
export function getProductsConfig(specifiedList?: string[]): IProduct[] {
  if (specifiedList && specifiedList.length > 0) {
    const list = specifiedList.map(pk => getItemForPk(pk));
    return list.filter(item => !!item) as IProduct[];
  }
  return [];
}

/**
 * 兼容在产品列表分开，但需要在体验中心合并的情况（例：消毒灯，在产品列表分为两款，但在体验中心用同一个模版）
 * @param {Arrary} specifiedList
 */
// 服务端获取并需要展示在体验中心的产品
export const remoteExpPks = [
  '355b74809cd44da192e699631e9f312b', // 灯
  '162866a5336c4a92a7edba1a2b07b182', // 插座
  'c9686e24e2f1459889742d92ba6bd993', // 面板开关
  '78e625cca186412f9c4dae1e1f3d68f4', // 消毒灯
  'cf26b5221bb3432ebfbf199429659a4b', // 温控器
  '5ff8b6ed150a4782b3712c791a0bf998', // 空气净化器
  'f61bbb89bfa1437cb748148dd5f833dd', // 净水器
  '851a55825b16468089fcf64473a5a607', // 热水器
  'b722e1b468804067b175e7b45e540d03', // 热泵
  '3b308239c1774c03b0c3582a7d673623', // 除湿机
  '12a9c7749aae4211ad41d5614940f4ba', // 空气检测仪
  '880c384080a54307a16530d68a95200e', // 电压力锅
  '172e87d93a62449291040da9e7cdf942', // 安防主机
  'fc678b9af916476090bd944f12f8f3d2', // 门磁
  '21bdec43d3664c9eaddf37077dc31165', // 烟雾报警器
  '5b7cfe1e6b4d4f9c9e9b6499dc1384bb', // 气体报警器
  'df6fff8f27454c70acf53f9cdd265f28', // 门锁
  '2c70dae2e40b4b04a6ecd65cebf81682', // 香薰机
  '6d991f46acea47fc8f9b9b15e1106adb', // 鱼缸加热棒
  'aca1cdee8267424cb30f9832e1d9e52b', // 蚊香器
];

export function getGroupAndExpConfig(specifiedList: IProduct[]) {
  const list = specifiedList || getConfig();
  return list.filter(item => {
    if (item) {
      if (item.gid) {
        /**
         * 有分组的产品
         * 只引入分组，不需要引入分组的其他产品
         */
        return item.mainGroup;
      }

      /**
       * 消毒灯专用
       */
      if (item.expId) {
        // 存在expId
        return item.mainGroup;
      }

      /**
       * 动态更新的产品不加入体验中心
       */
      if (item.isFromRemote && remoteExpPks.indexOf(item.productKey) === -1) {
        return false;
      }
      // 不存在
      return true;
    }
    // 产品不存在
    return false;
  });
}

/**
 * 获取品牌
 * @return { Array } 返回品牌数组
 */
export function getAllBrand(languageKey: string = 'en') {
  // 先按品牌过滤
  const list = getConfig();
  const data: any = {};
  list.map(item => {
    if (item.brand && item.brand.id) {
      if (!data[item.brand.id]) {
        const language = item.language[languageKey] || item.language[languageKey.slice(0, 2)] || item.language.en;
        data[item.brand.id] = {
          ...item.brand,
          name: language[item.brand.name],
          products: [],
        };
      }
      data[item.brand.id].products.push(item);
    }
  });
  return Object.keys(data).map(key => ({ ...data[key], id: key }));
}

interface IGetBrandProps {
  brandID: string;
  languageKey?: string;
}

/**
 * 获取品牌
 * @return { Object } 返回单个品牌
 */
export function getBrand({ brandID, languageKey = 'en' }: IGetBrandProps) {
  const brands = getAllBrand(languageKey);
  return brands.find(item => item.id === brandID);
}

// 获取配置文件下，该pk所在组的全部支持分组的设备pk列表
export function getAllSupportGroupConfig(productKey: string) {
  const list = getConfig();
  let arr = [];
  const product: any = list.find(item => item.productKey === productKey);
  if (product.gid) {
    // 存在gid，则需要找到全部同组类型设备
    arr = list.filter(item => item.gid === product.gid && item.supportGroup === true);
  } else {
    arr = [product];
  }
  return arr.map(item => item.productKey);
}

/**
 * 根据productConfig 筛选同一个分组的产品
 * 没有gid就返回自己
 */
export function getGroupProductWithID(config: IProduct): IProduct[] {
  if (!config.gid) {
    // 不存在GID 则返回自己
    return [config];
  }
  const list = getConfig();
  return list.filter(item => {
    if (item.gid === config.gid) {
      return true;
    }
    return false;
  });
}

/**
 * 根据gid，查询对应的主分组产品
 * @param gid 要查询的gid
 */
export function getMainGroupProductWithID(gid: string): IProduct {
  const list = getConfig();
  let p = list.find(item => item.gid === gid && item.mainGroup);
  if (p) {
    const res = checkConfigModelIsSupportFromProduct(p);
    p = { ...p, networkConfigType: res.networkConfigType || [] };
  }
  return p;
}

/**
 * 根据pk，查找配置，
 * 再比对，哪个配置拥有更多的功能
 * 这个配置就是优先的
 * 用在判断跳转分组模版的时候
 * 加载哪个配置
 * @param {*} list
 */
export function getPriorityProduct(list: string[]) {
  const data = {
    productKey: '',
    num: 0,
  };
  list.map(item => {
    const productItem = getItemForPk(item);
    if (!productItem) {
      return;
    }
    let num = 0;
    if (
      productItem &&
      productItem.templateConfig &&
      productItem.templateConfig.featureList &&
      productItem.templateConfig.featureList.length
    ) {
      productItem.templateConfig.featureList.map((feature: IFeature) => {
        if (feature.isActive && feature.isFeatureCount !== false) {
          num += 1;
        }
      });
    }

    if (data.num < num) {
      if (typeof productItem.productKey === 'string') {
        data.productKey = productItem.productKey;
      } else {
        // eslint-disable-next-line prefer-destructuring
        data.productKey = productItem.productKey[0];
      }
      data.num = num;
    }
  });
  return data.productKey;
}

/**
 * 是否是mesh蓝牙网关
 */
export function isMeshGateway(config: IProduct) {
  if (config.m2mProtoc === 'MESH' && config.isGatewayProduct) {
    return true;
  }
  return false;
}

/**
 * 是否是mesh 子设备
 */
export function isMeshSubDevice(config: IProduct) {
  if (config.m2mProtoc === 'MESH' && config.isGatewaySubdeviceProduct) {
    return true;
  }
  return false;
}

/**
 * 是否是NB
 */
export function isNB(config: IProduct) {
  if (config.m2mProtoc === 'NBIOT') {
    return true;
  }
  return false;
}

/**
 * 是否是GPRS
 */
export function isGPRS(config: IProduct) {
  if (config.m2mProtoc === 'CELLULAR') {
    return true;
  }
  return false;
}

export function isWifi(config: IProduct) {
  if (config.m2mProtoc === 'WIFI') {
    return true;
  }
  return false;
}

// 产品是否为蓝牙连接
// 产品是否为蓝牙连接
export function isBLEConnect(config: IProduct) {
  if (config.m2mProtoc === 'BLE' || config.m2mProtoc === 'BT') {
    return true;
  }
  return false;
}

// 产品是否为蓝牙广播
export function isBLEBroadCast(config: IProduct) {
  if (
    (config.m2mProtoc === 'BLE' && config.isBleBroadcast === true) ||
    config.m2mProtoc === 'BLE_BROADCAST' // 废弃
  ) {
    return true;
  }
  return false;
}

// 产品是否支持蓝牙
export function isBLE(config: IProduct) {
  return isBLEConnect(config) || isBLEBroadCast(config);
}

/**
 * 是否是网关
 */
export function isGateway(config: IProduct) {
  if (config.isGatewayProduct) {
    return true;
  }
  return false;
}

/**
 * 是否是第三方设备
 */
export function isThirdCloud(config: IProduct) {
  if (config.m2mProtoc === 'THIRD_CLOUD') {
    return true;
  }
  return false;
}

/**
 * 是否是蓝牙配网
 */
export function isBTWifiConfig(config: IProduct) {
  if (config.networkConfigType && config.networkConfigType.includes('BT_WIFI')) {
    return true;
  }
  return false;
}

export function isAlertOrFaultSceneItem(scene: ISceneItem) {
  if (scene && scene.type && (scene.type === 'alert' || scene.type === 'fault')) {
    return true;
  }
  return false;
}

export function getAlertTaskTypes({ productItem, templateComp }: { productItem: any; templateComp: any }) {
  const alertTaskTypes: any[] = [];
  const configData = productItem.scene ? productItem.scene.taskTypes || [] : [];
  // eslint-disable-next-line max-len
  const templateData =
    templateComp && templateComp.getSceneTaskTypes ? templateComp.getSceneTaskTypes(productItem.templateConfig) : [];
  let sceneAlertTaskTypes = [];
  if (configData && configData.length > 0) {
    sceneAlertTaskTypes = [...configData];
  } else {
    sceneAlertTaskTypes = [...templateData];
  }
  sceneAlertTaskTypes = sceneAlertTaskTypes.filter(i => isAlertOrFaultSceneItem(i));
  if (sceneAlertTaskTypes) {
    sceneAlertTaskTypes.map(item => {
      if (item.support && item.support.includes('condition')) {
        // 支持
        alertTaskTypes.push(item);
      }
    });
  }
  return alertTaskTypes;
}

export function getLocalProducts() {
  return productJson.product_list;
}

let canConfigNetworkProfucts: IProduct[];

export function getCanConfigNetworkProfucts() {
  console.log('getCanConfigNetworkProfucts');
  if (!canConfigNetworkProfucts) {
    const list = getConfig();

    // 小程序目前只支持这么多配网方式
    canConfigNetworkProfucts = getGroupConfig(
      list.filter(item => isBLE(item) || isWifi(item) || isGPRS(item) || isNB(item))
    );
    // canConfigNetworkProfucts = canConfigNetworkProfucts.filter(i => i.networkConfigType && (i.networkConfigType.includes(TNetworkConfigTypeAuto) || i.networkConfigType.includes(TNetworkConfigTypeSoftAp) || i.networkConfigType.includes(TNetworkConfigTypeBTWifi))) || [];
  }
  console.log('canConfigNetworkProfucts', canConfigNetworkProfucts);
  return canConfigNetworkProfucts;
}

export function getExperienceCenterList() {
  const list = getConfig();
  return list.filter(item => !item.disableExperience && (isBLE(item) || isWifi(item) || isGPRS(item) || isNB(item)));
}

export function getWxModeId(config: IProduct) {
  return config.wxModelId;
}

export function checkConfigModelIsSupportFromProduct(product: IProduct) {
  if (isBLE(product)) {
    return { support: false };
  }
  const { networkConfigType, usingAdapter } = product;
  if (networkConfigType && networkConfigType.length > 0) {
    const newList = new Set();
    networkConfigType.map(i => {
      switch (i) {
        case networkConfigTypes.TNetworkConfigTypeAuto:
          // Auto的话，就是等于[Airlink,softAp]
          newList.add(networkConfigTypes.TNetworkConfigTypeSoftAp);
          break;
        case networkConfigTypes.TNetworkConfigTypeBTWifi:
          newList.add(networkConfigTypes.TNetworkConfigTypeBTWifi);
          break;
        case networkConfigTypes.TNetworkConfigTypeSoftAp:
          newList.add(networkConfigTypes.TNetworkConfigTypeSoftAp);
          break;
        default:
          break;
      }
    });
    const arr = Array.from(newList);
    if (arr.length > 0) {
      return { support: true, networkConfigType: arr };
    }
    return { support: false };
  }
  if (usingAdapter && usingAdapter === 'GizAdapterWifiBle') {
    // 没有配置的话，双模默认是蓝牙配网
    return { support: true, networkConfigType: [networkConfigTypes.TNetworkConfigTypeBTWifi] };
  }
  // 没有配置的话，单模默认是softAP
  return { support: true, networkConfigType: [networkConfigTypes.TNetworkConfigTypeSoftAp] };
}

export function getConfigsSupportConfigNetwork() {
  // const list = ProductConfig.getConfig();
  const list = getGroupConfig();
  const arr: IProduct[] = [];
  list.map((i: IProduct): void => {
    const res = checkConfigModelIsSupportFromProduct(i);
    // if (res.support) {
    // 这里需要把转化后的配置类型放进去，不直接使用配置文件的
    const newItem = { ...i, networkConfigType: res.networkConfigType || [] };
    arr.push(newItem);
    // }
  });
  // console.log('arr', arr);
  return arr;
}

export function needBleAbility() {
  // 根据产品判断是否需要蓝牙能力
  const list = getCanConfigNetworkProfucts();
  return list.findIndex(i => i.networkConfigType.includes(TNetworkConfigTypeBTWifi) || isSupportBLEControl(i)) > -1;
}

export function haveDeviceTimeCorrect(config: IProduct) {
  return config.deviceTimeCorrect == true;
}

export function isSupportPasswordVerify(config: IProduct) {
  return config.passwordVerify === true;
}

export function getCmdLimitProduct(productKey: string) {
  if (productKey) {
    const config = getItemForPk(productKey);
    if (config && config.sendCmdLinit) {
      return config.sendCmdLinit;
    }
  }
  return undefined;
}

export function isSupportBLEControl(config: IProduct) {
  // console.log('isSupportBLEControl', config);
  if (
    config &&
    ((config.usingAdapter === 'GizAdapterWifiBle' && config.supportBleControl !== false) || isBLE(config))
  ) {
    return true;
  }
  return false;
}

export function isSupportBLEAdd(config: IProduct) {
  console.log('isSupportBLEAdd', config);
  if (isSupportBLEControl(config)) {
    if (config.supportBleAdd === false) {
      return false;
    }
    return true;
  }
  return false;
}

// 是否有支持蓝牙添加的产品
export function haveBleAddProduct() {
  const list = getConfig();
  return list.findIndex(i => isSupportBLEAdd(i)) > -1;
}

// 是否有除了蓝牙添加之外的产品
export function noOnlyBleAddProduct() {
  const list = getConfig();
  return list.findIndex(i => !isBLE(i)) > -1;
}

export function isSupportBLEConfig(config: IProduct) {
  return (
    config &&
    config.networkConfigType.includes(networkConfigTypes.TNetworkConfigTypeBTWifi) &&
    config.usingAdapter === 'GizAdapterWifiBle'
  );
}

// 是否有支持蓝牙配网的产品
export function haveSupportBLEConfig() {
  const list = getConfig();
  return list.findIndex(i => isSupportBLEConfig(i)) > -1;
}

// 产品是否支持分享
export function getConfigSupportShare(config: IProduct) {
  return config.supportDeviceShare;
}

// 产品是否支持分享
export function getConfigSupportShareFromPK(productKey: string) {
  const config = getItemForPk(productKey);
  return config && getConfigSupportShare(config);
}

export {
  IProduct,
  // TNetworkConfigTypeEnu,
  IConfigDeviceTips,
};
